import axios from "axios";
import {BASE_URL} from "./constant";
let cfg = {
    baseURL: BASE_URL,
    withCredentials: true,
    timeout: 1000 * 30,
    headers: { 'Content-Type': 'application/json' }
}
const service = axios.create(cfg)
service.interceptors.request.use(config => {
    let token = sessionStorage.getItem("token")
    if (token != null) {
        config.headers = config.headers || {}
        config.headers['token'] = token
    }
    // config.headers['Access-Control-Allow-Origin'] = '*'; // 允许跨域
    return config;
}, error => {
    Promise.reject(error);
})

service.interceptors.response.use(response => {
    // 接收到响应数据并成功后的一些共有的处理，关闭loading等
    let res = response.data
    if (res) {
        return response;
    } else {
        throw response;
    }
}, error => {
    debugger
    /** *** 接收到异常响应的处理开始 *****/
    if (error && error.response) {
        switch (error.response.status) {
            case 400:
                error.message = '错误请求';
                break;
            case 401:
                error.message = '未授权，请重新登录';
                break;
            case 403:
                error.message = '拒绝访问';
                break;
            case 404:
                error.message = '请求错误,未找到该资源';
                // window.location.href = '#/404';
                break;
            case 405:
                error.message = '请求方法未允许';
                break;
            case 408:
                error.message = '请求超时';
                break;
            case 500:
                error.message = '服务器端出错';
                break;
            case 501:
                error.message = '网络未实现';
                break;
            case 502:
                error.message = '网络错误';
                break;
            case 503:
                error.message = '服务不可用';
                break;
            case 504:
                error.message = '网络超时';
                break;
            case 505:
                error.message = 'http版本不支持该请求';
                break;
            default:
                error.message = `连接错误${error.response.status}`;
        }
    } else {
        // 超时处理
        if (JSON.stringify(error).includes('timeout')) {
            error.message = '连接服务器失败'
        }
        error.message = '连接服务器失败';
    }
    return Promise.resolve(error.response);
})
/**
 * get方法，对应get请求
 * @param {String} url [请求的url地址]
 * @param {Object} params [请求时携带的参数]
 *  export function get(url, params) {
        return instance.get(url, { params: params });
    }
 */
export function get(url, params,headers={}) {
    return new Promise((resolve, reject) => {
        service.get(url, {
            params: params
        }, {headers}).then(res => {
            resolve(res.data);
        }).catch(err => {
            reject(err.data)
        })
    });
}

/** 
 * post方法，对应post请求 
 * @param {String} url [请求的url地址] 
 * @param {Object} params [请求时携带的参数] 
 *  export function post(url, data) {
        return instance.post(url, data);
    }
 */
export function post(url, params, headers={}) {
    return new Promise((resolve, reject) => {
        service.post(url, params,{headers})
            .then(res => {
                resolve(res.data);
            })
            .catch(err => {
                reject(err.data)
            })
    });
}

export  async function sendStreamRequest (url,method, data, headers, callback) {
    let that = this;
    const response = await fetch(
      url,
      {
        method,
        cache: 'no-cache',
        mode: 'cors',
        headers,
        body: JSON.stringify(data),
      }
    ).then(response => {
        if (!response.ok || response.status !== 200) {
            callback(false, '请求失败，可能是需要编辑的文本太多了。', null)
            return
        }
      //     function read() {
      //   return reader.read().then(({ done, value }) => {
      //     if (done) {
      //       console.log('Stream complete');
      //       return;
      //     }
      //     console.log(value);
      //     return read(); // 继续读取
      //   });
      // }
      // return read();
    console.log(response);
      const reader = response.body.getReader();
      let buffer = ''; // 用于累积数据块
      let resultWord = ''; //返回的答案
      function read() {
        reader
          .read()
          .then(({ done, value }) => {
            if (done) {
              // 尝试解析最后一个数据块（如果有的话）
              if (buffer) {
                try {
                  const lastChunk = buffer.trim().replace(/^data:/, ''); // 移除可能的 'data:' 前缀并去除首尾空白
                  const json = JSON.parse(lastChunk);
                  // 处理最后一个JSON对象
                  console.log(json);
                } catch (e) {
                  console.error('Error parsing last chunk:', e);
                }
              }
              console.log('Stream complete');

              return;
            }
            // let str = decodeURIComponent(value);
            // 将新读取的数据块添加到缓冲区中
            const decode = new TextDecoder('utf-8')
            const chunk = decode.decode(value,{ stream: true });
            buffer += chunk;
            // 尝试按行分割数据块并处理
            const lines = buffer.split(/\r?\n/);
            let fullLines = lines.slice(0, -1); // 最后一行可能是不完整的，所以保留在缓冲区中
            buffer = lines.slice(-1)[0]; // 更新缓冲区为剩余的不完整行
            // console.log(fullLines, 'fullLines');
            fullLines.forEach(line => {
              const jsonString = line.trim().replace(/^data:/, ''); // 移除 'data:' 前缀并去除首尾空白
              
              
              try {
                if (line) {
                  const json = JSON.parse(jsonString);
                  print(json)
                  if (json.answer) {
                  
                    resultWord += json.answer
                    callback(true,resultWord,json.conversation_id)
                    // console.log(resultWord, 'resultWord');
                  }else if (json.error) {
                    resultWord = "唉呀，服务器开小差了..."
                    callback(false, resultWord,json.conversation_id)
                  }
                  
                  // 处理每个JSON对象
                //   console.log(json.data.content, json, 'json');
                //   resultWord += json.data.content;
                //   console.log(resultWord, 'resultWord');
                }
              } catch (e) {
                console.error('Error parsing JSON:', e, 'in line:', line);
              }
            });

            // 递归调用 read 方法以继续读取流
            read();
          })
          .catch(error => console.error('Error reading stream:', error));
      }
      read();
    });
  }

//   fetch(url)
//   .then(response => {
//     if (!response.ok) {
//       throw new Error('Network response was not ok');
//     }
//     const reader = response.body.getReader();
//     return new ReadableStream({
//       start(controller) {
//         function push() {
//           reader.read().then(({ done, value }) => {
//             if (done) {
//               controller.close();
//               return;
//             }
//             controller.enqueue(value);
//             push();
//           }).catch(error => {
//             controller.error(error);
//           });
//         }
//         push();
//       }
//     });
//   })
//   .then(stream => new Response(stream))
//   .then(response => response.text())
//   .then(text => {
//     // 使用 TextDecoder 明确指定编码，例如 'utf-8'
//     const decoder = new TextDecoder('utf-8');
//     const decodedText = decoder.decode(new Uint8Array(text));
//     console.log(decodedText);
//   })
//   .catch(error => {
//     console.error('Fetch error:', error);
//   });

export default service